package com.hspedu.InnerClass;


/**
 * @Author Stringzhua
 * @Date 2024/3/6 15:43
 * description:匿名内部类
 * 1.本质还是类
 * 2.内部类
 * 3.该类没有名字
 * 4.同时还是一个对象
 * 说明:匿名内部类是定义在外部类的局部位置,比如方法中,并且没有类名
 * <p>
 * 演示匿名内部类基于接口的基本语法
 * new 类或接口(参数列表){
 * 类体
 * };
 */
public class AnonymousInnerClass {//外部其他类

    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}

class Outer04 {//外部类
    private int n1 = 10;//属性

    public void method() {//方法
        /*基于接口的匿名内部类
         * 解读:
         * 1.需求:想使用接口IA,并创建对象
         * 2.传统方式,写一个类,实现该接口,并创建对象
         * 3.需求是:Tiger类只是使用一次,以后再不使用
         * 4.解决办法:可以使用匿名类来简化开发
         * */
        //5.tiger的编译类型是IA
        //6.运行类型是匿名内部类 XXX=>Outer04$1
        /*
        * 我们看底层
        *
        * class XXX implements IA{
        *   @Override
            public void cry() {
                System.out.println("老虎叫~");
            }
        * }
        * */

        //7.JDK底层在创建匿名内部类 Outer04$1
        //立即马上就创建了Outer04$1实例
        //并且马上把地址返回给tiger
        //8.匿名内部类使用一次就不能再使用了
        IA tiger = new IA() {//匿名内部类
            @Override
            public void cry() {
                System.out.println("老虎叫~");
            }
        };
        System.out.println("tiger的运行类型是 = " + tiger.getClass());//tiger的运行类型是 = class com.hspedu.InnerClass.Outer04$1
        tiger.cry();
        tiger.cry();
        tiger.cry();
        tiger.cry();
        tiger.cry();
//        Tiger tiger = new Tiger();//传统方法
//        tiger.cry();

        /*
         * 演示基于类的匿名内部类
         * 分析:
         * 1.father的编译类型 Father
         * 2.father的运行类型 Outer04$2
         * 3.底层会创建匿名内部类
         *
         * class Outer04$2 extends Father{
                @Override
                public void test() {
                    System.out.println("匿名内部类重写了test()方法");
                }
         * }
         * 4.同时也直接返回了 匿名内部类 Outer04$2对象
         * 这里的参数列表jack-->会传递给Father构造器
         * */
        Father father = new Father("jack") {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test()方法");
            }
        };
        System.out.println("father对象的运行类型=" + father.getClass());//father对象的运行类型=class com.hspedu.InnerClass.Outer04$2
        father.test();

        //基于抽象类的匿名内部类
        Animal animal=new Animal(){
            @Override
            void eat() {
                System.out.println("小狗狗吃骨头~");
            }
        };
    }
}

interface IA {//接口

    public void cry();
}

//class Tiger implements IA {
//
//    @Override
//    public void cry() {
//        System.out.println("老虎叫~");
//    }
//}

//class Dog implements IA{
//
//    @Override
//    public void cry() {
//        System.out.println("小狗叫~");
//    }
//}

class Father {//类

    public Father(String name) {
        System.out.println("接收到的name = " + name);
        //构造器
    }

    public void test() {
        ///方法
    }
}

abstract class Animal{//抽象类
    abstract void eat();
}


